import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:cached_network_image/cached_network_image.dart';
import '../../../common/services/index.dart';
import '../../../common/models/index.dart';
import '../../../common/api/index.dart';
import '../../../common/routers/names.dart';
import '../../../common/utils/format_util.dart';
import '../../../common/utils/loading_util.dart';
import 'dart:developer' as developer;

/// 🔥 好友消息列表项（用于"好友消息"标签页）
class FriendMessageItem {
  final int friendId;           // 好友数据库ID
  final String friendPhone;     // 好友手机号（融云用户ID）
  final String friendName;      // 好友名称
  final String friendAvatar;    // 好友头像
  final String friendSignature; // 🔥 好友签名（显示在副标题）
  final String lastMessage;     // 最后一条消息内容
  final int lastMessageTime;    // 最后一条消息时间戳
  final int unreadCount;        // 未读消息数量
  final int lastContactTime;    // 最后联系时间（收到或发送消息的时间）
  final bool isMe;              // 最后一条消息是否是我发送的
  
  FriendMessageItem({
    required this.friendId,
    required this.friendPhone,
    required this.friendName,
    required this.friendAvatar,
    required this.friendSignature,
    required this.lastMessage,
    required this.lastMessageTime,
    required this.unreadCount,
    required this.lastContactTime,
    required this.isMe,
  });
  
  /// 🔥 格式化副标题显示（显示最后一条消息内容，微信式）
  String get formattedSubtitle {
    // 🔥 优先显示最后一条消息内容
    if (lastMessage.isNotEmpty) {
      // 限制消息长度
      const maxLength = 30;
      String content = lastMessage;
      
      // 添加前缀
      String prefix = isMe ? '我: ' : '';
      
      // 截断过长的消息
      if (content.length > maxLength) {
        content = content.substring(0, maxLength) + '...';
      }
      
      return '$prefix$content';
    }
    
    // 🔥 没有消息则显示提示
    return '点击开始聊天';
  }
  
  /// 格式化签名显示（备用）
  String get formattedSignature {
    if (friendSignature.isNotEmpty) {
      return friendSignature;
    }
    return '';
  }
  
  /// 🔥 企业级时间格式化（使用 FormatUtil 工具类）
  /// 规则：刚刚 -> N分钟前 -> HH:mm -> 昨天 HH:mm -> N天前 -> MM-dd HH:mm
  String get formattedTime {
    // 🔥 如果没有消息，不显示时间
    if (lastMessage.isEmpty) {
      return '';
    }
    
    // 🔥 使用统一的工具类方法
    return FormatUtil.formatChatTimeFromTimestamp(lastMessageTime);
  }
}

/// 消息/好友列表页面控制器
/// 
/// 🎯 核心职责（遵循企业级架构标准）：
/// - 从 UserService 获取好友列表和好友申请列表数据
/// - 监听 UserService 的响应式变化，自动更新 UI
/// - 管理 UI 状态（加载中、错误等）
/// - 管理 TabBar 切换
/// - 处理好友操作（同意/拒绝申请、删除好友）
/// 
/// ✅ 新架构设计（职责清晰）：
/// 1. 数据获取：调用 UserService 获取/刷新数据
/// 2. 业务操作：直接调用 FriendApi 执行操作
/// 3. 数据同步：操作成功后调用 UserService.refreshFriendData() 刷新
/// 
/// 这样做的好处：
/// - 职责单一：Service 专注数据管理，Controller 专注业务逻辑
/// - 灵活性高：不同页面可以根据需要直接调用 API
/// - 减少耦合：避免 Service 过于臃肿
/// 
/// 遵循GetX控制器标准化结构
class MessageIndexController extends GetxController with GetSingleTickerProviderStateMixin {
  // 1. 静态常量
  static const String tag = 'MessageIndexController';
  
  // 2. 响应式变量（UI 状态）
  var currentTabIndex = 0.obs;  // 当前 Tab 索引（0=好友消息，1=好友申请，2=活动申请）
  var isLoading = false.obs;
  var isLoadingRequests = false.obs;
  var isLoadingActivityApplications = false.obs;
  var isRefreshing = false.obs;
  var hasError = false.obs;
  var errorMessage = ''.obs;
  
  // 3. TabBar 控制器
  TabController? tabController;
  
  // 4. 普通变量
  bool _isInitialized = false;
  
  // 5. 服务依赖
  UserService get _userService => Get.find<UserService>();
  
  // 6. 从 UserService 获取数据（企业级标准）
  int get currentUserId => _userService.currentUserProfile?.userid ?? 0;
  
  // ✅ 好友列表：直接从 UserService 获取
  List<FriendEntity> get friendList => _userService.friendList;
  int get friendCount => _userService.friendCount;
  
  // ✅ 好友申请列表：显示所有申请（包括待处理和已处理）
  List<FriendRequestEntity> get friendRequestList => _userService.friendRequestList;
  
  // 🔥 待处理的好友申请列表
  List<FriendRequestEntity> get pendingFriendRequests =>
      _userService.friendRequestList
          .map(_normalizeFriendRequestStatus)
          .where((request) => request.isPending)
          .toList();
  
  // 🔥 已处理的好友申请列表（已同意或已拒绝）
  List<FriendRequestEntity> get processedFriendRequests =>
      _userService.friendRequestList
          .map(_normalizeFriendRequestStatus)
          .where((request) => !request.isPending)
          .toList();
  
  /// 申请发起人是否已经出现在好友列表中
  bool _isSenderAlreadyFriend(FriendRequestEntity request) {
    final senderId = request.senderId;
    if (senderId == null) return false;
    return friendList.any((friend) => friend.friendId == senderId);
  }
  
  /// 后端状态与好友关系不同步时，进行本地纠正
  FriendRequestEntity _normalizeFriendRequestStatus(
      FriendRequestEntity request) {
    if (request.isPending || request.isAccepted) {
      return request;
    }
    if (_isSenderAlreadyFriend(request)) {
      return request.copyWith(status: 'accepted');
    }
    return request;
  }
  
  // 🔥 待处理的申请数量（用于角标显示）
  int get friendRequestCount => pendingFriendRequests.length;
  
  // 🔥 活动申请列表
  List<ParticipantEntity> pendingActivityApplications = [];
  List<ParticipantEntity> processedActivityApplications = [];
  int get activityApplicationCount => pendingActivityApplications.length;
  
  // 🔥 好友消息列表（用于"好友消息"标签页）
  final RxList<FriendMessageItem> friendMessageList = <FriendMessageItem>[].obs;
  
  // 🔥 消息总数统计
  int get totalMessageCount {
    // 好友消息未读数 + 好友申请数 + 活动申请数
    final chatUnread = friendMessageList.fold<int>(0, (sum, item) => sum + item.unreadCount);
    final requestCount = friendRequestCount;
    final activityCount = activityApplicationCount;
    final total = chatUnread + requestCount + activityCount;
    return total > 999 ? 999 : total;
  }
  
  // 🔥 格式化消息数量显示（最多999+）
  String formatMessageCount(int count) {
    if (count == 0) return '';
    if (count > 999) return '(999+)';
    return '($count)';
  }
  
  // 7. 初始化方法
  void _initData() {
    debugPrint('$tag: 初始化消息页面数据（企业级标准）');
    
    if (!_isInitialized) {
      // ✅ 先设置监听器（确保数据变化时自动更新UI）
      _setupUserServiceListeners();
      
      // ✅ 调用 UserService 获取数据（企业级标准）
      // 🔥 监听器会在好友列表变化时自动触发 _loadFriendMessageList()
      _loadFriendList();
      _loadFriendRequestList();
      _loadActivityApplications();
      // ❌ 移除直接调用 _loadFriendMessageList()，让监听器自动触发
      // 这样确保使用的是最新从服务器获取的好友数据，而不是本地缓存
      
      _isInitialized = true;
      debugPrint('$tag: 页面数据初始化完成');
    }
    
    update(["message_index"]);
  }
  
  /// 设置 UserService 响应式监听（企业级标准）
  void _setupUserServiceListeners() {
    debugPrint('$tag: 设置 UserService 数据监听');
    
    // ✅ 监听好友列表变化，自动刷新好友消息列表
    ever(_userService.friendListRx, (friendList) {
      debugPrint('$tag: 监听到好友列表变化，数量: ${friendList.length}');
      // 🔥 刷新好友消息列表
      _loadFriendMessageList();
      update(["message_index"]);
    });
    
    // ✅ 监听好友申请列表变化
    ever(_userService.friendRequestListRx, (requestList) {
      debugPrint('$tag: 监听到好友申请列表变化，数量: ${requestList.length}');
      update(["message_index"]);
    });
    
    // 🔥 监听消息存储变化，自动刷新好友消息列表
    try {
      final messageStorage = Get.find<MessageStorageService>();
      ever(messageStorage.messageChangeNotifier, (_) {
        debugPrint('$tag: 🔔 监听到消息变化，自动刷新好友消息列表');
        _loadFriendMessageList();
      });
      
      // 🔥 监听未读数变化，刷新好友消息列表（因为未读数是列表的一部分）
      ever(messageStorage.totalUnreadCount, (count) {
        debugPrint('$tag: 🔔 监听到未读数变化，总数: ${count.totalUnreadCount}');
        _loadFriendMessageList(); // 🔥 重新加载列表以更新未读数显示
        update(["message_index"]);
      });
    } catch (e) {
      debugPrint('$tag: ⚠️ 设置消息变化监听失败: $e');
    }
    
    // 🔥 初始加载：如果 UserService 已经有好友数据（比如从本地缓存加载的），
    // 立即加载一次消息列表（因为 ever 只在值变化时触发）
    if (_userService.friendList.isNotEmpty) {
      debugPrint('$tag: 🔄 检测到已有好友数据（${_userService.friendCount}个），立即加载消息列表');
      _loadFriendMessageList();
    }
  }
  
  // 8. 业务方法
  
  /// Tab 切换
  void onTabChange(int index) {
    debugPrint('$tag: 用户切换Tab: $index');
    tabController?.animateTo(index);
    currentTabIndex.value = index;
  }
  
  /// ✅ 加载好友列表（调用 UserService - 企业级标准）
  Future<void> _loadFriendList() async {
    if (currentUserId == 0) {
      debugPrint('$tag: ⚠️ 用户未登录，跳过加载好友列表');
      return;
    }
    
    try {
      isLoading.value = true;
      hasError.value = false;
      update(["message_index"]);
      
      debugPrint('$tag: 调用 UserService 获取好友列表');
      
      // ✅ 调用 UserService 获取好友列表（企业级标准）
      await _userService.getFriendList(forceRefresh: true);
      
      debugPrint('$tag: ✅ 好友列表加载成功，共 ${friendCount} 个好友');
      
    } catch (e) {
      debugPrint('$tag: ❌ 加载好友列表异常: $e');
      hasError.value = true;
      errorMessage.value = '加载好友列表失败';
    } finally {
      isLoading.value = false;
      update(["message_index"]);
    }
  }
  
  /// ✅ 加载好友申请列表（调用 UserService - 企业级标准）
  Future<void> _loadFriendRequestList() async {
    if (currentUserId == 0) {
      debugPrint('$tag: ⚠️ 用户未登录，跳过加载好友申请列表');
      return;
    }
    
    try {
      isLoadingRequests.value = true;
      update(["message_index"]);
      
      debugPrint('$tag: 调用 UserService 获取好友申请列表');
      
      // ✅ 调用 UserService 获取好友申请列表（企业级标准）
      await _userService.getFriendRequestList(forceRefresh: true);
      
      debugPrint('$tag: ✅ 好友申请列表加载成功，共 ${friendRequestCount} 个申请');
      
    } catch (e) {
      debugPrint('$tag: ❌ 加载好友申请列表异常: $e');
    } finally {
      isLoadingRequests.value = false;
      update(["message_index"]);
    }
  }
  
  /// 刷新当前 Tab 的数据
  Future<void> refreshCurrentTab() async {
    if (currentTabIndex.value == 0) {
      // 🔥 刷新好友消息列表
      await refreshFriendMessageList();
    } else if (currentTabIndex.value == 1) {
      await refreshFriendRequestList();
    } else {
      await refreshActivityApplications();
    }
  }
  
  /// ✅ 刷新好友列表（遵循新架构设计）
  Future<void> refreshFriendList() async {
    try {
      isRefreshing.value = true;
      hasError.value = false;
      update(["message_index"]);
      
      debugPrint('$tag: 刷新好友列表');
      
      // ✅ 调用 UserService 刷新数据（新架构）
      await _userService.refreshFriendData(
        refreshFriendList: true,
        refreshRequestList: false,
      );
      
      debugPrint('$tag: ✅ 好友列表刷新完成');
      
    } catch (e) {
      debugPrint('$tag: ❌ 刷新好友列表失败: $e');
      hasError.value = true;
      errorMessage.value = '刷新失败，请重试';
    } finally {
      isRefreshing.value = false;
      update(["message_index"]);
    }
  }
  
  /// ✅ 刷新好友申请列表（遵循新架构设计）
  Future<void> refreshFriendRequestList() async {
    try {
      isRefreshing.value = true;
      update(["message_index"]);
      
      debugPrint('$tag: 刷新好友申请列表');
      
      // ✅ 调用 UserService 刷新数据（新架构）
      await _userService.refreshFriendData(
        refreshFriendList: false,
        refreshRequestList: true,
      );
      
      debugPrint('$tag: ✅ 好友申请列表刷新完成');
      
    } catch (e) {
      debugPrint('$tag: ❌ 刷新好友申请列表失败: $e');
    } finally {
      isRefreshing.value = false;
      update(["message_index"]);
    }
  }
  
  /// 🔥 处理好友申请（同意/拒绝）- 遵循新架构设计
  /// 
  /// ✅ 新架构：
  /// 1. 直接调用 FriendApi 执行操作
  /// 2. 操作成功后调用 UserService.refreshFriendData() 刷新数据
  Future<void> handleFriendRequest(FriendRequestEntity request, String action) async {
    try {
      debugPrint('$tag: 处理好友申请 - $action');
      
      // 显示加载
      Get.dialog(
        const Center(child: CircularProgressIndicator()),
        barrierDismissible: false,
      );
      
      // 验证 requestId
      if (request.requestId == null) {
        debugPrint('$tag: ❌ 申请ID为空，无法处理');
        Get.back(); // 关闭加载
        LoadingUtil.error('申请ID无效');
        return;
      }
      
      // ✅ 1. 直接调用 FriendApi 处理申请（新架构）
      final response = await FriendApi.handleFriendRequest(
        requestId: request.requestId!,
        action: action,
      );
      
      // 关闭加载
      Get.back();
      
      if (response['status'] == 'success') {
        debugPrint('$tag: ✅ 好友申请${action == 'accept' ? '同意' : '拒绝'}成功');
        
        // ✅ 2. 调用 UserService 刷新数据（新架构）
        debugPrint('$tag: 刷新好友数据...');
        if (action == 'accept') {
          // 同意：刷新好友列表和申请列表
          await _userService.refreshFriendData();
        } else {
          // 拒绝：只刷新申请列表
          await _userService.refreshFriendData(
            refreshFriendList: false,
            refreshRequestList: true,
          );
        }
        debugPrint('$tag: ✅ 数据刷新完成');
        
        // 显示成功提示
        LoadingUtil.success(response['message'] ?? '操作成功');
        
      } else {
        debugPrint('$tag: ❌ 处理好友申请失败: ${response['message']}');
        LoadingUtil.error(response['message'] ?? '操作失败');
      }
      
    } catch (e) {
      // 关闭可能的加载对话框
      if (Get.isDialogOpen == true) {
        Get.back();
      }
      
      debugPrint('$tag: ❌ 处理好友申请异常: $e');
      LoadingUtil.error('操作失败，请重试');
    }
  }
  
  /// 🔥 删除好友 - 遵循新架构设计
  /// 
  /// ✅ 新架构：
  /// 1. 直接调用 FriendApi 执行操作
  /// 2. 操作成功后调用 UserService.refreshFriendData() 刷新数据
  Future<void> deleteFriend(FriendEntity friend) async {
    try {
      debugPrint('$tag: 删除好友 ${friend.username}');
      
      // 显示确认对话框
      final bool? confirm = await Get.dialog<bool>(
        AlertDialog(
          title: const Text('确认删除'),
          content: Text('确定要删除好友"${friend.username}"吗？'),
          actions: [
            TextButton(
              onPressed: () => Get.back(result: false),
              child: const Text('取消'),
            ),
            TextButton(
              onPressed: () => Get.back(result: true),
              style: TextButton.styleFrom(foregroundColor: Colors.red),
              child: const Text('删除'),
            ),
          ],
        ),
      );
      
      if (confirm != true) return;
      
      // 验证 friendId
      if (friend.friendId == null) {
        debugPrint('$tag: ❌ 好友ID为空，无法删除');
        LoadingUtil.error('好友ID无效');
        return;
      }
      
      // 显示加载
      Get.dialog(
        const Center(child: CircularProgressIndicator()),
        barrierDismissible: false,
      );
      
      // ✅ 1. 直接调用 FriendApi 删除好友（新架构）
      final response = await FriendApi.deleteFriend(
        userId: currentUserId,
        friendId: friend.friendId!,
      );
      
      // 关闭加载
      Get.back();
      
      if (response['status'] == 'success') {
        debugPrint('$tag: ✅ 好友删除成功');
        
        // ✅ 2. 调用 UserService 刷新好友列表（新架构）
        debugPrint('$tag: 刷新好友列表...');
        await _userService.refreshFriendData(
          refreshFriendList: true,
          refreshRequestList: false,
        );
        debugPrint('$tag: ✅ 数据刷新完成');
        
        // 显示成功提示
        LoadingUtil.success(response['message'] ?? '好友已删除');
        
      } else {
        debugPrint('$tag: ❌ 删除好友失败: ${response['message']}');
        LoadingUtil.error(response['message'] ?? '删除失败');
      }
      
    } catch (e) {
      // 关闭可能的加载对话框
      if (Get.isDialogOpen == true) {
        Get.back();
      }
      
      debugPrint('$tag: ❌ 删除好友异常: $e');
      LoadingUtil.error('删除失败，请重试');
    }
  }
  
  /// 好友项点击 - 跳转到聊天页面
  void onFriendTap(FriendEntity friend) {
    debugPrint('$tag: 用户点击好友: ${friend.username}');
    
    // ✅ 跳转到聊天页面（使用 Get.toNamed - 常规页面跳转）
    Get.toNamed(
      RouteNames.messageMessageChat,
      arguments: {
        'friendId': friend.friendId,           // 数据库ID（用于UI）
        'friendPhone': friend.userPhone,       // 🔥 手机号（用于融云）
        'friendName': friend.username ?? '未知用户',
        'friendAvatar': friend.userAvatarUrl ?? '',
        'friend': friend, // 传递完整好友对象
      },
    );
    
    debugPrint('$tag: 跳转到聊天页面 - 好友: ${friend.username} (ID: ${friend.friendId}, 手机: ${friend.userPhone})');
  }
  
  /// 好友申请项点击
  void onFriendRequestTap(FriendRequestEntity request) {
    debugPrint('$tag: 用户点击好友申请: ${request.senderName}');
    // TODO: 显示好友申请详情/处理申请
  }
  
  /// 好友头像点击 - 跳转到用户主页
  void onAvatarTap(int? friendId) {
    if (friendId == null) {
      debugPrint('$tag: ⚠️ 好友ID为空，无法跳转');
      return;
    }
    
    debugPrint('$tag: 用户点击好友头像，跳转到用户主页 - 用户ID: $friendId');
    
    Get.toNamed(
      RouteNames.myUserInfo,
      arguments: {
        'userId': friendId,
      },
    );
  }
  
  /// 好友申请头像点击 - 跳转到用户主页
  void onRequestAvatarTap(int? senderId) {
    if (senderId == null) {
      debugPrint('$tag: ⚠️ 发送者ID为空，无法跳转');
      return;
    }
    
    debugPrint('$tag: 用户点击申请者头像，跳转到用户主页 - 用户ID: $senderId');
    
    Get.toNamed(
      RouteNames.myUserInfo,
      arguments: {
        'userId': senderId,
      },
    );
  }
  
  // ==================== 活动申请相关方法 ====================
  
  /// 🔥 加载活动申请列表
  Future<void> _loadActivityApplications() async {
    if (currentUserId == 0) {
      debugPrint('$tag: ⚠️ 用户未登录，跳过加载活动申请列表');
      return;
    }
    
    try {
      isLoadingActivityApplications.value = true;
      update(["message_index"]);
      
      debugPrint('$tag: 调用 ActivityApi 获取活动申请列表');
      
      final response = await ActivityApi.getPublisherActivityParticipants(
        publisherId: currentUserId,
      );
      
      if (response.isSuccess) {
        pendingActivityApplications = response.pendingParticipants;
        processedActivityApplications = [
          ...response.approvedParticipants,
          ...response.rejectedParticipants
        ];
        
        debugPrint('$tag: ✅ 活动申请列表加载成功');
        debugPrint('$tag: ⏳ 待审核: ${pendingActivityApplications.length}');
        debugPrint('$tag: ✅ 已处理: ${processedActivityApplications.length}');
      } else {
        debugPrint('$tag: ❌ 活动申请列表加载失败: ${response.message}');
      }
      
    } catch (e) {
      debugPrint('$tag: ❌ 加载活动申请列表异常: $e');
    } finally {
      isLoadingActivityApplications.value = false;
      update(["message_index"]);
    }
  }
  
  /// 🔥 刷新活动申请列表
  Future<void> refreshActivityApplications() async {
    try {
      isRefreshing.value = true;
      update(["message_index"]);
      
      debugPrint('$tag: 刷新活动申请列表');
      
      await _loadActivityApplications();
      
      debugPrint('$tag: ✅ 活动申请列表刷新完成');
      
    } catch (e) {
      debugPrint('$tag: ❌ 刷新活动申请列表失败: $e');
    } finally {
      isRefreshing.value = false;
      update(["message_index"]);
    }
  }
  
  /// 🔥 审核活动申请（通过）
  Future<void> approveActivityApplication(ParticipantEntity application) async {
    try {
      debugPrint('$tag: 通过活动申请 - 用户: ${application.userName}');
      
      // 显示加载
      Get.dialog(
        const Center(child: CircularProgressIndicator()),
        barrierDismissible: false,
      );
      
      final response = await ActivityApi.reviewParticipantApplication(
        activityId: application.activityId,
        userId: application.userId,
        reviewStatus: '通过',  // 🔥 必须使用中文（与小程序保持一致）
      );
      
      // 关闭加载
      Get.back();
      
      if (response.isSuccess) {
        debugPrint('$tag: ✅ 活动申请已通过');
        
        // 刷新列表
        await _loadActivityApplications();
        
        LoadingUtil.success('已通过申请');
        
      } else {
        debugPrint('$tag: ❌ 审核失败: ${response.message}');
        LoadingUtil.error(response.message);
      }
      
    } catch (e) {
      // 关闭可能的加载对话框
      if (Get.isDialogOpen == true) {
        Get.back();
      }
      
      debugPrint('$tag: ❌ 审核活动申请异常: $e');
      LoadingUtil.error('审核失败，请重试');
    }
  }
  
  /// 🔥 审核活动申请（拒绝）
  Future<void> rejectActivityApplication(ParticipantEntity application, {String? note}) async {
    try {
      debugPrint('$tag: 拒绝活动申请 - 用户: ${application.userName}');
      
      // 显示加载
      Get.dialog(
        const Center(child: CircularProgressIndicator()),
        barrierDismissible: false,
      );
      
      final response = await ActivityApi.reviewParticipantApplication(
        activityId: application.activityId,
        userId: application.userId,
        reviewStatus: '未通过',  // 🔥 必须使用中文（与小程序保持一致）
        reviewNote: note,
      );
      
      // 关闭加载
      Get.back();
      
      if (response.isSuccess) {
        debugPrint('$tag: ✅ 活动申请已拒绝');
        
        // 刷新列表
        await _loadActivityApplications();
        
        LoadingUtil.success('已拒绝申请');
        
      } else {
        debugPrint('$tag: ❌ 审核失败: ${response.message}');
        LoadingUtil.error(response.message);
      }
      
    } catch (e) {
      // 关闭可能的加载对话框
      if (Get.isDialogOpen == true) {
        Get.back();
      }
      
      debugPrint('$tag: ❌ 审核活动申请异常: $e');
      LoadingUtil.error('审核失败，请重试');
    }
  }
  
  /// 活动申请用户头像点击 - 跳转到用户主页
  void onActivityApplicationAvatarTap(int? userId) {
    if (userId == null) {
      debugPrint('$tag: ⚠️ 用户ID为空，无法跳转');
      return;
    }
    
    debugPrint('$tag: 用户点击活动申请者头像，跳转到用户主页 - 用户ID: $userId');
    
    Get.toNamed(
      RouteNames.myUserInfo,
      arguments: {
        'userId': userId,
      },
    );
  }
  
  // ==================== 好友消息列表相关方法 ====================
  
  /// 🔥 加载好友消息列表（从好友列表和消息存储构建）
  Future<void> _loadFriendMessageList() async {
    try {
      developer.log('$tag: 🔄 开始加载好友消息列表');
      
      // 获取所有好友
      final friends = friendList;
      if (friends.isEmpty) {
        developer.log('$tag: ⚠️ 好友列表为空');
        friendMessageList.clear();
        return;
      }
      
      // 获取消息存储服务
      final messageStorage = Get.find<MessageStorageService>();
      
      // 构建好友消息列表
      final List<FriendMessageItem> items = [];
      
      for (final friend in friends) {
        final friendPhone = friend.userPhone ?? '';
        if (friendPhone.isEmpty) continue;
        
        // 获取该好友的最后一条消息
        final lastMsg = await messageStorage.getLastMessage(friendPhone);
        
        // 获取该好友的未读数
        final unreadCount = await messageStorage.getUserUnreadCount(friendPhone);
        final chatUnread = unreadCount.chatUnreadCount;
        
        // 确定最后一条消息时间和内容
        int lastMessageTime = DateTime.now().millisecondsSinceEpoch;
        String lastMessageContent = '';
        bool isMe = false;
        int lastContactTime = 0;
        
        if (lastMsg != null) {
          lastMessageTime = lastMsg.timestamp;
          lastMessageContent = lastMsg.content;
          isMe = lastMsg.isMe;
          lastContactTime = lastMsg.timestamp;
          
          // 🔥 调试日志：打印消息时间
          final msgTime = DateTime.fromMillisecondsSinceEpoch(lastMessageTime);
          developer.log('$tag: 📅 好友 ${friend.username} 的最新消息时间: $msgTime (时间戳: $lastMessageTime)');
        }
        
        // 创建消息项
        items.add(FriendMessageItem(
          friendId: friend.friendId ?? 0,
          friendPhone: friendPhone,
          friendName: friend.username ?? '未知用户',
          friendAvatar: friend.userAvatarUrl ?? '',
          friendSignature: friend.userSignature ?? '',  // 🔥 添加好友签名
          lastMessage: lastMessageContent,
          lastMessageTime: lastMessageTime,
          unreadCount: chatUnread,
          lastContactTime: lastContactTime,
          isMe: isMe,
        ));
      }
      
      // 🔥 微信式排序
      final sortedItems = _sortFriendMessageList(items);
      
      friendMessageList.value = sortedItems;
      
      developer.log('$tag: ✅ 好友消息列表加载完成，共 ${sortedItems.length} 个会话');
      
    } catch (e) {
      developer.log('$tag: ❌ 加载好友消息列表异常: $e');
    }
  }
  
  /// 🔥 微信式排序好友消息列表
  /// 规则：
  /// 1. 有未读消息的排在最前面
  /// 2. 未读数量相同时，按最后联系时间排序（最近联系的在前）
  /// 3. 如果都没有联系记录，按最后消息时间排序
  List<FriendMessageItem> _sortFriendMessageList(List<FriendMessageItem> items) {
    items.sort((a, b) {
      // 1. 有未读的排在前面
      if (a.unreadCount > 0 && b.unreadCount == 0) {
        return -1; // a 在前
      }
      if (a.unreadCount == 0 && b.unreadCount > 0) {
        return 1; // b 在前
      }
      
      // 2. 如果都有未读，未读数量多的在前
      if (a.unreadCount > 0 && b.unreadCount > 0 && a.unreadCount != b.unreadCount) {
        return b.unreadCount - a.unreadCount;
      }
      
      // 3. 按最后联系时间排序（核心改进：无论有无未读，最近联系的都在前面）
      final contactTimeA = a.lastContactTime;
      final contactTimeB = b.lastContactTime;
      
      // 如果有联系时间记录，优先按联系时间排序
      if (contactTimeA > 0 || contactTimeB > 0) {
        return contactTimeB - contactTimeA; // 时间越大（越新）越在前
      }
      
      // 4. 如果都没有联系记录，按最后消息时间排序
      return b.lastMessageTime - a.lastMessageTime;
    });
    
    developer.log('$tag: 🔄 好友消息列表已排序，最近联系的在最前面');
    return items;
  }
  
  /// 🔥 刷新好友消息列表（完整流程：先刷新好友列表，再自动刷新消息列表）
  /// 
  /// 执行流程：
  /// 1. 先从服务器获取最新的好友列表（forceRefresh: true）
  /// 2. UserService 更新好友列表后，监听器自动触发 _loadFriendMessageList()
  /// 3. 消息列表使用最新的好友数据重新构建，实现无感知刷新
  Future<void> refreshFriendMessageList() async {
    try {
      debugPrint('$tag: 🔄 刷新好友消息列表（先获取最新好友数据）');
      
      // 🔥 步骤1：先刷新好友列表（从服务器获取最新数据）
      // 这会触发 UserService 的响应式更新，监听器会自动调用 _loadFriendMessageList()
      await _loadFriendList();
      
      debugPrint('$tag: ✅ 好友数据已刷新，消息列表已自动更新');
      
    } catch (e) {
      debugPrint('$tag: ❌ 刷新好友消息列表失败: $e');
    }
  }
  
  /// 🔥 好友消息项点击 - 跳转到聊天页面
  void onFriendMessageTap(FriendMessageItem item) {
    debugPrint('$tag: 用户点击好友消息: ${item.friendName}');
    
    // 跳转到聊天页面
    Get.toNamed(
      RouteNames.messageMessageChat,
      arguments: {
        'friendId': item.friendId,
        'friendPhone': item.friendPhone,
        'friendName': item.friendName,
        'friendAvatar': item.friendAvatar,
      },
    );
    
    debugPrint('$tag: 跳转到聊天页面 - 好友: ${item.friendName} (ID: ${item.friendId}, 手机: ${item.friendPhone})');
  }
  
  /// 🔥 好友消息项长按 - 显示删除选项
  Future<void> onFriendMessageLongPress(FriendMessageItem item) async {
    debugPrint('$tag: 用户长按好友消息: ${item.friendName}');
    
    // 显示操作菜单
    Get.bottomSheet(
      Container(
        decoration: const BoxDecoration(
          color: Colors.white,
          borderRadius: BorderRadius.only(
            topLeft: Radius.circular(20),
            topRight: Radius.circular(20),
          ),
        ),
        child: SafeArea(
          child: Column(
            mainAxisSize: MainAxisSize.min,
            children: [
              // 顶部指示条
              Container(
                margin: const EdgeInsets.only(top: 12, bottom: 20),
                width: 40,
                height: 4,
                decoration: BoxDecoration(
                  color: Colors.grey[300],
                  borderRadius: BorderRadius.circular(2),
                ),
              ),
              
              // 好友信息
              Padding(
                padding: const EdgeInsets.symmetric(horizontal: 20),
                child: Row(
                  children: [
                    CircleAvatar(
                      radius: 24,
                      backgroundColor: Colors.grey[200],
                      backgroundImage: item.friendAvatar.isNotEmpty 
                          ? CachedNetworkImageProvider(item.friendAvatar)
                          : null,
                      child: item.friendAvatar.isEmpty 
                          ? Icon(Icons.person, size: 28, color: Colors.grey[400])
                          : null,
                    ),
                    const SizedBox(width: 12),
                    Expanded(
                      child: Column(
                        crossAxisAlignment: CrossAxisAlignment.start,
                        children: [
                          Text(
                            item.friendName,
                            style: const TextStyle(
                              fontSize: 16,
                              fontWeight: FontWeight.w600,
                              color: Color(0xFF333333),
                            ),
                          ),
                          // 🔥 显示签名而不是最后一条消息
                          if (item.formattedSubtitle.isNotEmpty)
                            Text(
                              item.formattedSubtitle,
                              style: TextStyle(
                                fontSize: 13,
                                color: Colors.grey[600],
                              ),
                              maxLines: 1,
                              overflow: TextOverflow.ellipsis,
                            ),
                        ],
                      ),
                    ),
                  ],
                ),
              ),
              
              const SizedBox(height: 20),
              const Divider(height: 1),
              
              // 删除好友选项
              Material(
                color: Colors.transparent,
                child: InkWell(
                  onTap: () {
                    Get.back(); // 关闭底部菜单
                    _deleteFriendWithConfirm(item);
                  },
                  child: Container(
                    padding: const EdgeInsets.symmetric(vertical: 16, horizontal: 20),
                    child: Row(
                      children: [
                        Icon(
                          Icons.person_remove_outlined,
                          color: Colors.red[600],
                          size: 24,
                        ),
                        const SizedBox(width: 12),
                        Text(
                          '删除好友',
                          style: TextStyle(
                            fontSize: 16,
                            color: Colors.red[600],
                            fontWeight: FontWeight.w500,
                          ),
                        ),
                      ],
                    ),
                  ),
                ),
              ),
              
              const Divider(height: 1),
              
              // 取消按钮
              Material(
                color: Colors.transparent,
                child: InkWell(
                  onTap: () => Get.back(),
                  child: Container(
                    padding: const EdgeInsets.symmetric(vertical: 16),
                    alignment: Alignment.center,
                    child: const Text(
                      '取消',
                      style: TextStyle(
                        fontSize: 16,
                        color: Color(0xFF666666),
                        fontWeight: FontWeight.w500,
                      ),
                    ),
                  ),
                ),
              ),
              
              const SizedBox(height: 8),
            ],
          ),
        ),
      ),
      backgroundColor: Colors.transparent,
      isDismissible: true,
    );
  }
  
  /// 🗑️ 删除好友（带确认对话框，并清空聊天记录）
  Future<void> _deleteFriendWithConfirm(FriendMessageItem item) async {
    // 显示确认对话框
    final bool? confirm = await Get.dialog<bool>(
      AlertDialog(
        shape: RoundedRectangleBorder(
          borderRadius: BorderRadius.circular(16),
        ),
        title: Row(
          children: [
            Container(
              padding: const EdgeInsets.all(8),
              decoration: BoxDecoration(
                color: Colors.red.withOpacity(0.1),
                borderRadius: BorderRadius.circular(8),
              ),
              child: Icon(
                Icons.warning_amber_rounded,
                color: Colors.red[600],
                size: 24,
              ),
            ),
            const SizedBox(width: 12),
            const Text(
              '确认删除好友',
              style: TextStyle(
                fontSize: 18,
                fontWeight: FontWeight.w600,
              ),
            ),
          ],
        ),
        content: Column(
          mainAxisSize: MainAxisSize.min,
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text(
              '确定要删除好友"${item.friendName}"吗？',
              style: const TextStyle(
                fontSize: 15,
                color: Color(0xFF333333),
              ),
            ),
            const SizedBox(height: 12),
            Container(
              padding: const EdgeInsets.all(12),
              decoration: BoxDecoration(
                color: Colors.orange.withOpacity(0.1),
                borderRadius: BorderRadius.circular(8),
                border: Border.all(
                  color: Colors.orange.withOpacity(0.3),
                  width: 1,
                ),
              ),
              child: Row(
                children: [
                  Icon(
                    Icons.info_outline,
                    color: Colors.orange[700],
                    size: 20,
                  ),
                  const SizedBox(width: 8),
                  Expanded(
                    child: Text(
                      '删除后将清空与该好友的所有聊天记录',
                      style: TextStyle(
                        fontSize: 13,
                        color: Colors.orange[800],
                        height: 1.4,
                      ),
                    ),
                  ),
                ],
              ),
            ),
          ],
        ),
        actions: [
          TextButton(
            onPressed: () => Get.back(result: false),
            child: const Text(
              '取消',
              style: TextStyle(
                fontSize: 15,
                color: Color(0xFF666666),
              ),
            ),
          ),
          TextButton(
            onPressed: () => Get.back(result: true),
            style: TextButton.styleFrom(
              foregroundColor: Colors.red[600],
            ),
            child: const Text(
              '删除',
              style: TextStyle(
                fontSize: 15,
                fontWeight: FontWeight.w600,
              ),
            ),
          ),
        ],
      ),
    );
    
    if (confirm != true) return;
    
    try {
      debugPrint('$tag: 开始删除好友 ${item.friendName} (ID: ${item.friendId})');
      
      // 显示加载
      Get.dialog(
        const Center(child: CircularProgressIndicator()),
        barrierDismissible: false,
      );
      
      // 1. 调用 FriendApi 删除好友
      final response = await FriendApi.deleteFriend(
        userId: currentUserId,
        friendId: item.friendId,
      );
      
      // 关闭加载
      Get.back();
      
      if (response['status'] == 'success') {
        debugPrint('$tag: ✅ 好友删除成功');
        
        // 2. 🔥 清空与该好友的所有聊天记录
        try {
          debugPrint('$tag: 🗑️ 开始清空聊天记录，好友手机号: ${item.friendPhone}');
          final messageStorage = Get.find<MessageStorageService>();
          
          // 清除聊天历史
          await messageStorage.clearMessages(item.friendPhone);
          
          // 清除未读数
          await messageStorage.clearUserUnreadCount(item.friendPhone);
          
          debugPrint('$tag: ✅ 聊天记录已清空');
        } catch (e) {
          debugPrint('$tag: ⚠️ 清空聊天记录失败: $e（不影响删除好友流程）');
        }
        
        // 3. 刷新好友列表和消息列表
        debugPrint('$tag: 刷新好友数据...');
        await _userService.refreshFriendData(
          refreshFriendList: true,
          refreshRequestList: false,
        );
        
        // 刷新好友消息列表
        await _loadFriendMessageList();
        
        debugPrint('$tag: ✅ 数据刷新完成');
        
        // 显示成功提示
        LoadingUtil.success('已删除好友"${item.friendName}"');
        
      } else {
        debugPrint('$tag: ❌ 删除好友失败: ${response['message']}');
        LoadingUtil.error(response['message'] ?? '删除好友失败');
      }
      
    } catch (e) {
      // 关闭可能的加载对话框
      if (Get.isDialogOpen == true) {
        Get.back();
      }
      
      debugPrint('$tag: ❌ 删除好友异常: $e');
      LoadingUtil.error('删除好友时发生错误，请重试');
    }
  }

  // 9. 生命周期方法
  @override
  void onInit() {
    super.onInit();
    debugPrint('$tag: onInit - 控制器初始化');
    
    // 🔥 初始化 TabController（必须在 onInit 中初始化，确保在 build 之前就绪）
    tabController = TabController(
      length: 3,  // 🔥 修改为3个标签：好友消息、好友申请、活动申请
      vsync: this,
      initialIndex: 0,
    );
    
    // 监听 Tab 切换
    tabController?.addListener(() {
      if (tabController?.indexIsChanging == false) {
        currentTabIndex.value = tabController?.index ?? 0;
        debugPrint('$tag: Tab切换到: ${currentTabIndex.value}');
      }
    });
  }

  @override
  void onReady() {
    super.onReady();
    debugPrint('$tag: onReady - 页面准备就绪');
    _initData();
  }

  @override
  void onClose() {
    debugPrint('$tag: onClose - 控制器销毁');
    tabController?.dispose();
    super.onClose();
  }
}
